home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MacQForth 1.0 / asm6502 / asm6502 source / asm.c next >
Text File  |  1995-02-27  |  27KB  |  437 lines
  2. {
  3.     if (lflag > 0)
  4.         fprintf(stdout, "%s\n", prlnbuf);
  5. }
  6.  
  7. /* colsym() collects a symbol from prlnbuf into symbol0[],
  8.  *    leaves prlnbuf pointer at first invalid symbol character,
  9.  *    returns 0 if no symbol collected
  10.  */
  11.  
  12. colsym(ip)
  13.     int *ip;
  14. {
  15.     int    valid;
  16.     int    i;
  17.     char    ch;
  18.  
  19.     valid = 1;
  20.     i = 0;
  21.     while (valid == 1) {
  22.         ch = prlnbuf[*ip];
  23.         if (ch == '_' || ch == '.');
  24.         else if (ch >= 'a' && ch <= 'z');
  25.         else if (ch >= 'A' && ch <= 'Z');
  26.         else if (i >= 1 && ch >= '0' && ch <= '9');
  27.         else if (i == 1 && ch == '=');
  28.         else valid = 0;
  29.         if (valid == 1) {
  30.             if (i < SBOLSZ - 1)
  31.                 symbol0[++i] = ch;
  32.             (*ip)++;
  33.         }
  34.     }
  35.     if (i == 1) {
  36.         switch (symbol0[1]) {
  37.         case 'A': case 'a':
  38.         case 'X': case 'x':
  39.         case 'Y': case 'y':
  40.             error("Symbol is reserved (A, X or Y)");
  41.             i = 0;
  42.         }
  43.     }
  44.     symbol0[0] = i;
  45.     return(i);
  46. }
  47.  
  48. /* symbol table lookup
  49.  *    if found, return pointer to symbol
  50.  *    else, install symbol as undefined, and return pointer
  51.  */
  52.  
  53. stlook()
  54. {
  55.     int    found;
  56.     int    hptr;
  57.     int    j;
  58.     int    nptr;
  59.     int    pptr;
  60.     int    ptr;
  61.  
  62.     hptr = 0;
  63.     for (j = 0; j < symbol0[0]; j++)
  64.         hptr += symbol0[j];
  65.     hptr %= 128;
  66.     ptr = hash_tbl[hptr];
  67.     if (ptr == -1) {        /* no entry for this link */
  68.         hash_tbl[hptr] = nxt_free;
  69.         return(stinstal());
  70.     }
  71.     while (symtab[ptr] != 0) {    /* 0 count = end of table */
  72.         found = 1;
  73.         for (j = 0; j <= symbol0[0]; j++) {
  74.             if (symbol0[j] != symtab[ptr + j]) {
  75.                 found = 0;
  76.                 pptr = ptr + symtab[ptr] + 4;
  77.                 nptr = (symtab[pptr + 1] << 8) + (symtab[pptr] & 0xff);
  78.                 nptr &= 0xffff;
  79.                 if (nptr == 0) {
  80.                     symtab[ptr + symtab[ptr] + 4] = nxt_free & 0xff;
  81.                     symtab[ptr + symtab[ptr] + 5] = (nxt_free >> 8) & 0xff;
  82.                     return(stinstal());
  83.                 }
  84.                 ptr = nptr;
  85.                 break;
  86.             }
  87.         }
  88.         if (found == 1)
  89.             return(ptr);
  90.     }
  91.     error("Symbol not found");
  92.     return(-1);
  93. }
  94.  
  95. /*  instal symbol into symtab
  96.  */
  97. stinstal()
  98. {
  99. register    int    j;
  100. register    int    ptr1;
  101. register    int    ptr2;
  102.  
  103.     ptr1 = ptr2 = nxt_free;
  104.     if ((ptr1 + symbol0[0] + 6) >= STABSZ) {
  105.         error("Symbol table full");
  106.         return(-1);
  107.     }
  108.     for (j = 0; j <= symbol0[0]; j++)
  109.         symtab[ptr1++] = symbol0[j];
  110.     symtab[ptr1] = udtype;
  111.     nxt_free = ptr1 + 5;
  112.     return(ptr2);
  113. }
  114.  
  115. /* operation code table lookup
  116.  *    if found, return pointer to symbol,
  117.  *    else, return -1
  118.  */
  119.  
  120. oplook(ip)
  121.    int    *ip;
  122. {
  123. register    char    ch;
  124. register    int    i;
  125. register    int    j;
  126.     int    k;
  127.     int    temp[2];
  128.  
  129.     i = j = 0;
  130.     temp[0] = temp[1] = 0;
  131.     while((ch=prlnbuf[*ip])!= ' ' && ch!= 0 && ch!= '\t' && ch!= ';') {
  132.         if (ch >= 'A' && ch <= 'Z')
  133.             ch &= 0x1f;
  134.         else if (ch >= 'a' && ch <= 'z')
  135.             ch &= 0x1f;
  136.         else if (ch == '.')
  137.             ch = 31;
  138.         else if (ch == '*')
  139.             ch = 30;
  140.         else if (ch == '=')
  141.             ch = 29;
  142.         else return(-1);
  143.         temp[j] = (temp[j] * 0x20) + (ch & 0xff);
  144.         if (ch == 29)
  145.             break;
  146.         ++(*ip);
  147.         if (++i >= 3) {
  148.             i = 0;
  149.             if (++j >= 2) {
  150.                 return(-1);
  151.             }
  152.         }
  153.     }
  154.     if ((j = temp[0]^temp[1]) == 0)
  155.         return(-2);
  156.     k = 0;
  157.     i = step[k] - 3;
  158.     do {
  159.         if (j == optab[i]) {
  160.             opflg = optab[++i];
  161.             opval = optab[++i];
  162.             return(i);
  163.         }
  164.         else if (j < optab[i])
  165.             i -= step[++k];
  166.         else i += step[++k];
  167.     } while (step[k] != 0);
  168.     return(-1);
  169. }
  170.  
  171. /* error printing routine */
  172.  
  173. error(stptr)
  174.    char *stptr;
  175. {
  176.     loadlc(loccnt, 0, 1);
  177.     loccnt += 3;
  178.     loadv(0,0,0);
  179.     loadv(0,1,0);
  180.     loadv(0,2,0);
  181.     fprintf(stdout, "%s\n", prlnbuf);
  182.     fprintf(stdout, "%s\n", stptr);
  183.     errcnt++;
  184. }
  185.  
  186. /* load 16 bit value in printable form into prlnbuf */
  187.  
  188. loadlc(val, f, outflg)
  189.     int val;
  190.     int f;
  191.     int outflg;
  192. {
  193.     int    i;
  194.  
  195.     i = 6 + 7*f;
  196.     hexcon(4, val);
  197.     if (nflag == 0) {
  198.         prlnbuf[i++]  = hex[3];
  199.         prlnbuf[i++]  = hex[4];
  200.         prlnbuf[i++]  = ':';
  201.         prlnbuf[i++]  = hex[1];
  202.         prlnbuf[i] = hex[2];
  203.     }
  204.     else {
  205.         prlnbuf[i++] = hex[1];
  206.         prlnbuf[i++] = hex[2];
  207.         prlnbuf[i++] = hex[3];
  208.         prlnbuf[i] = hex[4];
  209.     }
  210.     if ((pass == LAST_PASS)&&(oflag != 0)&&(objcnt <= 0)&&(outflg != 0)) {
  211.         fprintf(optr, "\n;%c%c%c%c", hex[3], hex[4], hex[1], hex[2]);
  212.         objcnt = 16;
  213.     }
  214. }
  215.  
  216.  
  217.  
  218. /* load value in hex into prlnbuf[contents[i]] */
  219. /* and output hex characters to obuf if LAST_PASS & oflag == 1 */
  220.  
  221. loadv(val,f,outflg)
  222.    int    val;
  223.    int    f;        /* contents field subscript */
  224.    int    outflg;        /* flag to output object bytes */
  225. {
  226.  
  227.     hexcon(2, val);
  228.     prlnbuf[13 + 3*f] = hex[1];
  229.     prlnbuf[14 + 3*f] = hex[2];
  230.     if ((pass == LAST_PASS) && (oflag != 0) && (outflg != 0)) {
  231.         fputc(hex[1], optr);
  232.         fputc(hex[2], optr);
  233.         --objcnt;
  234.     }
  235. }
  236.  
  237. /* convert number supplied as argument to hexadecimal in hex[digit] (lsd)
  238.         through hex[1] (msd)        */
  239.  
  240. hexcon(digit, num)
  241.     int digit;
  242.    int    num;
  243. {
  244.  
  245.     for (; digit > 0; digit--) {
  246.         hex[digit] = (num & 0x0f) + '0';
  247.         if (hex[digit] > '9')
  248.             hex[digit] += 'A' -'9' - 1;
  249.         num >>= 4;
  250.     }
  251. }
  252.  
  253. /* assign <value> to label pointed to by lablptr,
  254.  *    checking for valid definition, etc.
  255.  */
  256.  
  257. labldef(lval)
  258.     int lval;
  259. {
  260.     int    i;
  261.  
  262.     if (lablptr != -1) {
  263.         lablptr += symtab[lablptr] + 1;
  264.         if (pass == FIRST_PASS) {
  265.             if (symtab[lablptr] == UNDEF) {
  266.                 symtab[lablptr + 1] = lval & 0xff;
  267.                 i = symtab[lablptr + 2] = (lval >> 8) & 0xff;
  268.                 if (i == 0)
  269.                     symtab[lablptr] = DEFZRO;
  270.                 else    symtab[lablptr] = DEFABS;
  271.             }
  272.             else if (symtab[lablptr] == UNDEFAB) {
  273.                 symtab[lablptr] = DEFABS;
  274.                 symtab[lablptr + 1] = lval & 0xff;
  275.                 symtab[lablptr + 2] = (lval >> 8) & 0xff;
  276.             }
  277.             else {
  278.                 symtab[lablptr] = MDEF;
  279.                 symtab[lablptr + 1] = 0;
  280.                 symtab[lablptr + 2] = 0;
  281.                 error("Label multiply defined");
  282.                 return(-1);
  283.             }
  284.         }
  285.         else {
  286.             i = (symtab[lablptr + 2] << 8) +
  287.                 (symtab[lablptr+1] & 0xff);
  288.             i &= 0xffff;
  289.             if (i != lval && pass == LAST_PASS) {
  290.                 error("Sync error");
  291.                 return(-1);
  292.             }
  293.         }
  294.     }
  295.     return(0);
  296. }
  297.  
  298. /* determine the value of the symbol,
  299.  * given pointer to first character of symbol in symtab
  300.  */
  301.  
  302. symval(ip)
  303.     int *ip;
  304. {
  305.     int    ptr;
  306.     int    svalue;
  307.  
  308.     svalue = 0;
  309.     colsym(ip);
  310.     if ((ptr = stlook()) == -1)
  311.         undef = 1;        /* no room error */
  312.     else if (symtab[ptr + symtab[ptr] + 1] == UNDEF)
  313.         undef = 1;
  314.     else if (symtab[ptr + symtab[ptr] + 1] == UNDEFAB)
  315.         undef = 1;
  316.     else svalue = ((symtab[ptr + symtab[ptr] + 3] << 8) +
  317.         (symtab[ptr + symtab[ptr] + 2] & 0xff)) & 0xffff;
  318.     if (symtab[ptr + symtab[ptr] + 1] == DEFABS)
  319.         zpref = 1;
  320.     if (undef != 0)
  321.         zpref = 1;
  322.     return(svalue);
  323. }
  324.  
  325.  
  326. /* class 1 machine operations processor - 1 byte, no operand field */
  327.  
  328. class1()
  329. {
  330.     if (pass == LAST_PASS) {
  331.         loadlc(loccnt, 0, 1);
  332.         loadv(opval, 0, 1);
  333.         println();
  334.     }
  335.     loccnt++;
  336. }
  337.  
  338.  
  339. /* class 2 machine operations processor - 2 byte, relative addressing */
  340.  
  341. class2(ip)
  342.     int *ip;
  343. {
  344.  
  345.     if (pass == LAST_PASS) {
  346.         loadlc(loccnt, 0, 1);
  347.         loadv(opval, 0, 1);
  348.         while (prlnbuf[++(*ip)] == ' ');
  349.         if (evaluate(ip) != 0) {
  350.             loccnt += 2;
  351.             return;
  352.         }
  353.         loccnt += 2;
  354.         if ((value -= loccnt) >= -128 && value < 128) {
  355.             loadv(value, 1, 1);
  356.             println();
  357.         }
  358.         else error("Invalid branch address");
  359.     }
  360.     else loccnt += 2;
  361. }
  362.  
  363.  
  364. /* class 3 machine operations processor - various addressing modes */
  365.  
  366. class3(ip)
  367.     int *ip;
  368. {
  369.     char    ch;
  370.     int    code;
  371.     int    flag;
  372.     int    i;
  373.     int    ztmask;
  374.  
  375.     while ((ch = prlnbuf[++(*ip)]) == ' ');
  376.     switch(ch) {
  377.     case 0:
  378.     case ';':
  379.         error("Operand field missing");
  380.         return;
  381.     case 'A':
  382.     case 'a':
  383.         if ((ch = prlnbuf[*ip + 1]) == ' ' || ch == 0) {
  384.             flag = ACC;
  385.             break;
  386.         }
  387.     default:
  388.         switch(ch = prlnbuf[*ip]) {
  389.         case '#': case '=':
  390.             flag = IMM1 | IMM2;
  391.             ++(*ip);
  392.             break;
  393.         case '(':
  394.             flag = IND | INDX | INDY;
  395.             ++(*ip);
  396.             break;
  397.         default:
  398.             flag = ABS | ZER | ZERX | ABSX | ABSY | ABSY2 | ZERY;
  399.         }
  400.         if ((flag & (INDX | INDY | ZER | ZERX | ZERY) & opflg) != 0)
  401.             udtype = UNDEFAB;
  402.         if (evaluate(ip) != 0)
  403.             return;
  404.         if (zpref != 0) {
  405.             flag &= (ABS | ABSX | ABSY | ABSY2 | IND | IMM1 | IMM2);
  406.             ztmask = 0;
  407.         }
  408.         else ztmask = ZER | ZERX | ZERY;
  409.         code = 0;
  410.         i = 0;
  411.         while (( ch = prlnbuf[(*ip)++]) != ' ' && ch != 0 && i++ < 4) {
  412.             code *= 8;
  413.             switch(ch) {
  414.             case ')':        /* ) = 4 */
  415.                 ++code;
  416.             case ',':        /* , = 3 */
  417.                 ++code;
  418.             case 'X':        /* X = 2 */
  419.             case 'x':
  420.                 ++code;
  421.             case 'Y':        /* Y = 1 */
  422.             case 'y':
  423.                 ++code;
  424.                 break;
  425.             default:
  426.                 flag = 0;
  427.             }
  428.         }
  429.         switch(code) {
  430.         case 0:        /* no termination characters */
  431.             flag &= (ABS | ZER | IMM1 | IMM2);
  432.             break;
  433.         case 4:        /* termination = ) */
  434.             flag &= IND;
  435.             break;
  436.         case 25:        /* termination = ,Y */
  437.             flag &